package com.aifast.system.log.service;

import cn.hutool.core.convert.Convert;
import cn.hutool.core.lang.Console;
import cn.hutool.core.lang.UUID;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.aifast.common.base.R;
import com.aifast.common.cache.util.RedisUtil;
import com.aifast.common.layui.LayuiDataTable;
import com.aifast.common.layui.LayuiPageFactory;
import com.aifast.system.log.dao.LogOperationDao;
import com.aifast.system.log.entity.LogOperation;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author fujian
 * @since 2022-01-20
 */
@Service
@RequiredArgsConstructor
public class LogOperationService extends ServiceImpl<LogOperationDao, LogOperation> {

    private final LogOperationDao dao;

    /**
     * layui数据表格列表查询方法
     * <br>这里参数不使用参数类，当超过5个参数时筛选条件参数建议使用参数类param封装
     * @param search 关键字搜索
     * @param page   分页
     * @return 列表数据
     */
    public LayuiDataTable list(String search, Page page) {
        LambdaQueryWrapper<LogOperation> wrapper = new LambdaQueryWrapper<LogOperation>()
                .eq(StrUtil.isNotBlank(search), LogOperation::getDescription, search)
                .orderByDesc(LogOperation::getId);
        return LayuiPageFactory.init(page(page, wrapper));
    }

    /**
     * 新增或者修改
     * <br>vo的方法另写，里面有判定是否新增还是修改 可自定义逻辑
     *
     * @param logOperation
     * @return
     */
    public Boolean insertOrUpdate(LogOperation logOperation) {
        if (ObjectUtil.isNull(logOperation.getId())) {

        }
        return saveOrUpdate(logOperation);
    }

    /**
     * 删除方法
     * <br>提供单个删除和批量删除
     *
     * @param id  数据id
     * @param ids 数据id集合
     * @return
     */
    public Boolean del(Integer id, String ids) {
        List<Integer> integers = new ArrayList<>();
        if (StrUtil.isNotBlank(ids)) {
            integers = Convert.toList(Integer.class, ids.split(","));
        }
        if (ObjectUtil.isNotNull(id)) {
            integers.add(id);
        }
        try {
            integers.forEach(i -> {
                update(new UpdateWrapper<LogOperation>().set("deleted", 1).eq("id", i));
            });
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 数据详情
     *
     * @param id 数据id
     * @return
     */
    public R info(Integer id) {
        if (ObjectUtil.isNull(id)) return R.ERROR();
        LogOperation one = getOne(new QueryWrapper<LogOperation>().eq("id", id));
        return R.OK(one);
    }

    /**
     * 队列模式 消费日志
     * @param message 消息内容 （目前没啥卵用）
     */
    public void consume(String message) {
        while (true){
            try {
                String rpop = (String) RedisUtil.rpop(LogOperation.KEY);
                if(StrUtil.isBlank(rpop)){
                    break;
                }
                Thread.currentThread().setName(UUID.fastUUID().toString(true));

                LogOperation operation = JSONUtil.toBean(rpop, LogOperation.class);
                insertOrUpdate(operation);
            }catch (Exception e){
                Console.log(e.getMessage());
            }
        }


    }
}
